/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package clases;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletResponse;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.Projections;
import tablas.Banco;
import tablas.Cheque;
import tablas.ChequeId;
import tablas.Chequera;
import tablas.Cliente;
import tablas.Cuenta;
import tablas.Departamento;
import tablas.Descripcion;
import tablas.Empleado;
import tablas.Sucursal;
import tablas.Tarjeta;
import tablas.Transaccion;
import tablas.UserLog;

/**
 * Hibernate Utility class with a convenient method to get Session Factory object.
 *
 * @author ad
 */
public class Conexion {

    public static SessionFactory misessionFactory;
    private Transaction mitransaction;
    /**
     * carga el nombre del driver en este caso com.microsoft.sqlserver.jdbc.SQLSErverDriver
     **/
    private String drivers = "";//primer registro arch
    private String urls = "";//segundo registro arch
    /** unicos dos datos entre usuario_Base y password_base ya que los usuarios pueden ir variando
    dependiendo de quien se loguee.....**/
    private static String usuario_base = "";//tercer registro arch
    private static String password_base = "";//cuarto registro arch
    Connection connection = null;
    //direccion completa de localhost
    public static String localhost = "";
    /***cabercera utilizada para la tabla de auditoria.
     **/
    private final String cabecera_tablahtml1 = "<HR width=\"120%\">"
            + "<table border=2><tbody>"
            + "<tr><td> NUMERO DE TRANSACCION</td>"
            + "<td>NOMBRE DE EMPLEADO</td>"
            + "<td>DESCRIPCION</td>"
            + "<td>NUMERO DE CUENTA</td>"
            + "<td>FECHA DE REALIZACION</td>"
            + "<td>TIPO</td>"
            + "<td>VALOR DE TRANSACCION</td>"
            + "<td>SALDO INICIAL</td>"
            + "<td>SALDO FINAL</td>"
            + "<td>ESTADO</td>";

    public Conexion() {
        cargarArchivo();

    }

    /**
     * configura el los datos de conexion desde el archivo configurar.bin el cual tiene la cadena de
     * conexion hacia la base de datos
     **/
    private void cargarArchivo() {
        try {


            File x = new File("configurar.bin.txt");
            BufferedReader nuevo; //buffer lector
            nuevo = new BufferedReader(new InputStreamReader(new FileInputStream(x)));

            int i = 0;
            while (i < 5) {
                if (i == 0) {
                    drivers = nuevo.readLine();
                } else if (i == 1) {
                    urls = nuevo.readLine();
                } else if (i == 2) {
                    usuario_base = nuevo.readLine();
                } else if (i == 3) {
                    password_base = nuevo.readLine();
                } else if (i == 4) {
                    localhost = nuevo.readLine();
                }
                i++;
            }

            nuevo.close();//cerramos el buffer


        } catch (Exception ex) {
            Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /****
     * cargamos el archivo de configuracion y abrimos la conexion una sola vez
     * y se cierra hasta que se salga de la aplicacion.
     ****/
    public void configurar_Conexion(String usuarios, String passwords) {
        try {
            // Create the SessionFactory from standard (hibernate.cfg.xml)
            // config file.
            Configuration conf = new AnnotationConfiguration().configure("hibernate.cfg.xml");
            conf.setProperty("hibernate.connection.username", usuarios);
            conf.setProperty("hibernate.connection.password", passwords);
            misessionFactory = conf.buildSessionFactory();
            usuario_base = usuarios;
            password_base = passwords;
            //abrimos la conexion hacia la base de datos
            abrirSession();

            //sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

        } catch (Throwable ex) {
            // Log the exception.
            System.out.println("**************************************************************");
            System.err.println("Inicio de SessionFactory faido........." + ex.getMessage());
        }
    }

    public String verQuepermisostiene() {
        try {
            AbrirConexionJDBC();
            Statement stmt = null;
            stmt = connection.createStatement();
            //creamos el usuario
            String local = "select IS_MEMBER('usuario')";
            ResultSet a = stmt.executeQuery(local);
            while (a.next()) {
                int b = a.getInt(1);
                if (b == 1) {
                    return "usuario";
                }
            }
            //lo agregamos a un grupo en especifico
            local = "select IS_MEMBER('operador')";
            a = stmt.executeQuery(local);
            while (a.next()) {
                int b = a.getInt(1);
                if (b == 1) {
                    return "operador";
                }
            }
            //ahora verificamos en que rol nos pertenece el rol verdadero es sysadmin
            local = "select IS_MEMBER('db_owner')";
            a = stmt.executeQuery(local);
            while (a.next()) {
                int b = a.getInt(1);
                if (b == 1) {
                    return "gerente";
                }
            }
            stmt.close();
            CerrraConexionJDBC();

        } catch (SQLException ex) {
            Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
        }
        return "null";
    }

    /***
     * este metodo solo es llamado cuando se va a cerrar la session tantod del usuarion como
     * la sesion de nuestra pagina web
     ***/
    public static void cerrar_la_configuracion() {
        try {
            misessionFactory.close();
        } catch (Exception as) {
            System.out.println("cerrando la conexion de la configuracion.." + as.getMessage());
        }
    }

    /**
     * abre una sesion hacia la base de datos
     */
    private void abrirSession() {
        misessionFactory.openSession();
    }

    public Transaction iniciarTransaccion(Session session) {
        return session.beginTransaction();
    }

    public void realizarCommit(Transaction tx) {
        tx.commit();
    }

    public void realizarRollback(Transaction tx) {
        tx.rollback();
    }

    /**
     *carga el driver y obtiene la conexion este metodo solo es utilizable
     * para cuando se quiere hacer una consulta sql sobre la tabla user y login
     * de la basede datos solo para ese para todo lo demas se debera utilizar hibernate
     */
    private Connection AbrirConexionJDBC() {
        try {
            //lo creamos con jdbc
            Class.forName(drivers);
            connection = DriverManager.getConnection(urls, usuario_base, password_base);
            return connection;
        } catch (Exception ex) {
            System.out.println("Error al AbrirConexionJDBC" + ex.getMessage());
        }
        return connection;
    }

    /**
     * cierra la conexion de jdbc
     **/
    private void CerrraConexionJDBC() {
        try {
            connection.close();
        } catch (SQLException ex) {
            Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /***
     * crear un usuario nuevo en la base de datos
     **/
    public boolean CrearUsuario(String usuarioNuevo, String passwords, String[] matris, HttpServletResponse response, Error_Data misErrores, Tipo[] param) {
        try {
            Querys nuevo = new Querys();
            AbrirConexionJDBC();
            Statement stmt = null;
            stmt = connection.createStatement();
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //cominezo de la transaccion
            stmt.execute("begin tran");
            //creamos el usuario dependiendo de donde es asignado si es gerente o otro
            String local = "";
            Comparacion mi = new Comparacion();
            if (mi.verificarrolAsignadoGerente(matris)) {
                local = nuevo.crear_Login_nombre + usuarioNuevo + nuevo.crear_Login_Password + passwords + "' ,DEFAULT_DATABASE=[master];";//nuevo.crear_Login_Base;
            } else {
                local = nuevo.crear_Login_nombre + usuarioNuevo + nuevo.crear_Login_Password + passwords + "' ,DEFAULT_DATABASE=[mibase];";//nuevo.crear_Login_Base;
            }
            stmt.execute(local);
            //lo agregamos a un grupo en especifico
            local = nuevo.crear_usuario_nombre + usuarioNuevo + nuevo.crear_for_login + usuarioNuevo + ";";
            stmt.execute(local);

            boolean todo_bien = verificarTipoUsuario(usuarioNuevo, matris, response, misErrores, param);
            //hasta este momemto se creo el user y el login en nuestra base de datos
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------

            if (todo_bien)//entonces realizamos el commit
            {
                stmt.execute("commit tran");
                //ahora verificamos en que rol nos pertenece
                //YA QUE COMO MANDAMOS A LLAMAR A UN PROCEDIMIENTO ALMACENADO DIECE QUE NO PUEDE EJECUTARSE EN TRANSACCION

                local = verificarRolSeleccionado(matris, usuarioNuevo);
                stmt.execute(local);
            } else//si algo esta malo entonces realizamos el rollback a nuestra base de datos
            {
                stmt.execute("rollback tran");
            }

            //insertamso ya sea si es cliente o empleado dependiendo de la tabla
            //ahora ya tenemos el usuario y el cliente o empleado solo falta realacionarlo

            stmt.close();
            CerrraConexionJDBC();//esta conexion se la cerramos y abrimos cada vez que la necesitemos

            /****
             * si algo sucedio y esta malo entonces debemos de borrar
             **/
            if (todo_bien == false) {
                //a ocurrido un error ingrese de nuevo los datos
                return false;
            }
        } catch (Exception ex) {
            try {
                System.out.println(ex.getMessage());
                misErrores.EscribirMensajes(ex.getMessage(), response, "Regresar", "Usuario_Nuevo.jsp");
                return false;
            } catch (IOException ex1) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex1);
            }
        }

        return true;
    }

    /***
     * recibe el nombre
     * tipo puede ser solo web, cliente ,operador
     ***/
    public boolean EliminarUsuario(String nombre, String tipo, String eliminar) {
        Statement stmt = null;
        boolean res = false;
        try {

            AbrirConexionJDBC();

            stmt = connection.createStatement();
            //comenzamos la transaccion
            stmt.execute("begin tran");

            //eliminamos el login
            String local = "drop login " + nombre;
            int x = stmt.executeUpdate(local);
            //eliminamos el usuario
            local = "drop user " + nombre;
            x = stmt.executeUpdate(local);
            //y ahora debemos de remover el usuario de la tabla userlog esto por medio de hibernate
            res = eliminar_usuario_Tabla_userlog(nombre, tipo, eliminar);


            if (res == true) {
                stmt.execute("commit tran");
            } else {
                stmt.execute("rollback tran");
            }

            stmt.close();
            CerrraConexionJDBC();


        } catch (SQLException ex) {
            try {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
                if (stmt != null) {
                    stmt.execute("rollback tran");
                }
                return false;
            } catch (SQLException ex1) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex1);
            }
        }

        return res;
    }

    public boolean insertVisa(String visa_id_cuenta, String visa_estado, String visa_limite, String visa_tipo) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + visa_id_cuenta + "'");
            List milista = resultado.list();
            Cuenta m = (Cuenta) milista.get(0);
            Tarjeta miTarjeta = new Tarjeta();
            miTarjeta.setCuenta(m);
            miTarjeta.setEstado(visa_estado);
            miTarjeta.setLimite(new BigDecimal(visa_limite));
            miTarjeta.setTipo(visa_tipo);

            misessionFactory.getCurrentSession().save(miTarjeta);
            //si todo estubo bien realizamos el commit
            realizarCommit(mitransaction);

        } catch (Exception xs) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }            //mostramaos el error en la pantalla del usuario

            System.out.println("---- ---- ---- en metodo insertVisa " + xs.getMessage());
            return false;
        }

        return true;
    }

    public boolean CrearCuenta(String usuarioNuevo, String tipo) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where idCliente='" + usuarioNuevo + "'");
            List milista = resultado.list();

            Cliente m = (Cliente) milista.get(0);

            Cuenta nueva = new Cuenta();
            nueva.setSaldo(BigDecimal.ZERO);
            nueva.setEstado("Activa");
            nueva.setCliente(m);
            nueva.setDisponible(BigDecimal.ZERO);
            nueva.setTipo(tipo);
            nueva.setReserva(BigDecimal.ZERO);
      
            misessionFactory.getCurrentSession().save(nueva);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            realizarRollback(mitransaction);
            System.err.println("Error en el Metodo CrearCuenta ------- " + ex.getMessage());
            return false;
        }
    }

    /**
     * verifica que exista el usuario y la clave del usuario
     **/
    public boolean verificarLogin(String usuario, String clave) {
        try {
            Class.forName(drivers);
            try {
                connection = DriverManager.getConnection(urls, usuario, clave);
                connection.close();
            } catch (Exception q) {
                String t = q.getMessage();
                System.out.println(t);
                return false;
            }
            return true;
        } catch (Exception ss) {
            System.out.println(ss.getMessage());
        }
        return false;
    }

    /***
     * devuelve la lista de usuarios clientes, y empleados de la base}
     * de datos
     ***/
    public String devolverUsuarios(String t) {
        String devolver = "";
        try {


            if (t.compareTo("Usuario_web_all") == 0) {
                Querys nuevo = new Querys();
                AbrirConexionJDBC();
                Statement stmt = null;
                stmt = connection.createStatement();
                String local = nuevo.usuarios_Bases;

                // LinkedList lista_logueado=devolverlista_clientelogs();


                ResultSet respuesta = stmt.executeQuery(local);
                while (respuesta.next()) {
                    String nombres = respuesta.getString(1);
                    if (nombres.compareTo("admin") != 0) {
                        devolver += "<option value=\"" + nombres + "\">" + nombres + "</option>";

                    }

                }
                stmt.close();
                CerrraConexionJDBC();
            } else if (t.compareTo("Usuario_web") == 0) {
                Querys nuevo = new Querys();
                AbrirConexionJDBC();
                Statement stmt = null;
                stmt = connection.createStatement();
                String local = nuevo.usuarios_Bases;

                LinkedList lista_logueado = devolverlista_clientelogs();


                ResultSet respuesta = stmt.executeQuery(local);
                while (respuesta.next()) {
                    String nombres = respuesta.getString(1);
                    if (nombres.compareTo("admin") != 0 && lista_logueado.contains(nombres)) {
                        devolver += "<option value=\"" + nombres + "\">" + nombres + "</option>";

                    }

                }
                stmt.close();
                CerrraConexionJDBC();
            } else if (t.compareTo("cliente") == 0) {
                //cliente lo accedmos por medio de hibernate.
                devolver = Regresa_listas("Cliente");

            } else if (t.compareTo("empleado") == 0) {
                devolver = Regresa_listas("Empleado");

            }


        } catch (SQLException ex) {
            Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
        }
        return devolver;
    }

    public String devolverCuentas(String cliente) {
        String cuenta = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta,Cliente where idCliente=Cliente_idCliente and idCliente=" + cliente);
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //obtenemos todos los nombres de la tabla
                Object mi[] = (Object[]) milista.remove(0);
                Cuenta mis = (Cuenta) mi[0];
                cuenta += "<option value=\"" + mis.getIdCuenta() + "\">" + mis.getIdCuenta() + "</option>";

            }

            realizarCommit(mitransaction);
            return cuenta;
        } catch (Exception ex) {
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.err.println(ex.getMessage());
            return null;
        }

    }

    /***
     * recibe como parametro una matris la cual contiene el rol que se a definido
    supuestamente tiene cuatro roles
     ***/
    private String verificarRolSeleccionado(String[] matris, String usuario) {
        String k = "";
        if (matris[0] != null) {
            return "exec sp_addrolemember 'usuario','" + usuario + "';";
        } else if (matris[1] != null) {
            return "exec sp_addrolemember 'operador','" + usuario + "';";
        } else if (matris[2] != null) {
            //como es gerente puede eliminar al usuario entonces agregamos perimisos de sysadmin y lo mostramos como db_owner
            return "EXEC sys.sp_addsrvrolemember @loginame = N'" + usuario + "', @rolename = N'sysadmin'";
        } else if (matris[3] != null) {
            return null;
        }
        return k;
    }

    public boolean EditarDepartamento_H(String nombre_actual, String nombre_nuevo) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento where nombre='" + nombre_actual + "'");
            List milista = resultado.list();
            Departamento depto = (Departamento) milista.get(0);
            depto.setNombre(nombre_nuevo);
            misessionFactory.getCurrentSession().update(depto);
            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: en EditarDepartamento_H .... " + ex.getMessage());
            return false;
        }
    }

    /**
     * editara el estado de la Tarjeta
     * a un estado seleccionado
     */
    public boolean EditarEstadoVisa_H(String id_visa, String visa_estado_nuevo) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Tarjeta where idTarjeta='" + id_visa + "'");
            List milista = resultado.list();
            Tarjeta tarj = (Tarjeta) milista.get(0);
            tarj.setEstado(visa_estado_nuevo);
            misessionFactory.getCurrentSession().update(tarj);
            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: en EditarEstadoVisa_H .... " + ex.getMessage());
            return false;
        }
    }

    /**
     * editara el tipo de la Tarjeta
     * a un estado seleccionado
     */
    public boolean EditarTipoVisa_H(String id_visa, String visa_tipo) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Tarjeta where idTarjeta='" + id_visa + "'");
            List milista = resultado.list();
            Tarjeta tarj = (Tarjeta) milista.get(0);
            tarj.setTipo(visa_tipo);
            misessionFactory.getCurrentSession().update(tarj);
            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: en EditarTipoVisa_H .... " + ex.getMessage());
            return false;
        }
    }

    /**
     * editara el monto de la Tarjeta
     * a un estado seleccionado
     */
    public boolean EditarMontoVisa_H(String id_visa, String visa_limite) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Tarjeta where idTarjeta='" + id_visa + "'");
            List milista = resultado.list();
            Tarjeta tarj = (Tarjeta) milista.get(0);
            tarj.setLimite(new BigDecimal(visa_limite));
            misessionFactory.getCurrentSession().update(tarj);
            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: en EditarMontoVisa_H .... " + ex.getMessage());
            return false;
        }
    }

    /**
     * devolvera los nombres Departamentos a
     * una lista de seleccion HTML
     */
    public String devolverDepartamentosListaSeleccion() {
        String devolver = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                Departamento depto = (Departamento) milista.remove(0);
                devolver += "<option value=\"" + depto.getIdDepartamento() + "\">" + depto.getNombre() + "</option>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return devolver;

    }

    /**
     * devolvera el id depto
     * una lista de seleccion HTML
     */
    public String devolverDepartamentosIDListaSeleccion() {
        String devolver = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                Departamento depto = (Departamento) milista.remove(0);
                devolver += "<option value=\"" + depto.getIdDepartamento() + "\">" + depto.getNombre() + "</option>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return devolver;

    }

    /**
     * devolvera el id sucursal
     * una lista de seleccion HTML
     */
    public String devolverSucursalIDListaSeleccion() {
        String devolver = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Sucursal");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                Sucursal sucu = (Sucursal) milista.remove(0);
                devolver += "<option value=\"" + sucu.getIdSucursal() + "\">" + sucu.getNombre() + "</option>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return devolver;

    }

    public String devolverSaldosPorTarjeta(String tarjeta) {
        String saldo = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta,Tarjeta where idCuenta=Cuenta_idCuenta and idTarjeta=" + tarjeta);
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //obtenemos todos los nombres de la tabla
                Object mi[] = (Object[]) milista.remove(0);
                Cuenta ins_cuenta = (Cuenta) mi[0];
                saldo += "<TR><TD>" + ins_cuenta.getSaldo() + "</TD><TD>" + ins_cuenta.getEstado() + "</TD><TR>";
            }

            realizarCommit(mitransaction);
            return saldo;
        } catch (Exception ex) {
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }
            System.err.println(ex.getMessage());
            return null;
        }

    }

    public String DevolverIdCuentaListaSeleccion() {
        String lista_opciones = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta");
            List milista = resultado.list();
            while (!milista.isEmpty()) {
                Cuenta c = (Cuenta) milista.remove(0);
                lista_opciones += "<option value=\"" + c.getIdCuenta() + "\">" + c.getIdCuenta() + "</option>";
            }
            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }
            System.out.println(ex.getMessage());
        }
        return lista_opciones;
    }

    public String DevolverIdVisaListaSeleccion() {
        String lista_opciones = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Tarjeta");
            List milista = resultado.list();
            while (!milista.isEmpty()) {
                Tarjeta t = (Tarjeta) milista.remove(0);
                lista_opciones += "<option value=\"" + t.getIdTarjeta() + "\">" + t.getIdTarjeta() + "</option>";
            }
            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }
            System.out.println(ex.getMessage());
        }
        return lista_opciones;
    }

    public boolean EliminarDepartamento_H(String nombre) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento where nombre='" + nombre + "'");
            List milista = resultado.list();
            Departamento depto = (Departamento) milista.get(0);

            misessionFactory.getCurrentSession().delete(depto);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: metodo EliminarDepartamento_H ...." + ex.getMessage());
            return false;
        }

    }

    public boolean EliminarSucursal_H(String id_sucursal) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Sucursal where idSucursal='" + id_sucursal + "'");
            List milista = resultado.list();
            Sucursal sucu = (Sucursal) milista.get(0);

            misessionFactory.getCurrentSession().delete(sucu);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: metodo EliminarSucursal_H ...." + ex.getMessage());
            return false;
        }

    }

    public boolean EliminarVisa_H(String id_visa) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Tarjeta where idTarjeta='" + id_visa + "'");
            List milista = resultado.list();
            Tarjeta tar = (Tarjeta) milista.get(0);
            misessionFactory.getCurrentSession().delete(tar);

            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: metodo EliminarDepartamento_H ...." + ex.getMessage());
            return false;
        }
    }

    /***
     * metodo el cual hace un update a login y  para cambiar el password
     **/
    public boolean actualizarPasswordusuario(String nombre, String clave1, String antiguo) {

        //buscamos wl password actual de nuestro usuario
        //exec sp_password '1','123','uu'
        try {

            Querys lista = new Querys();
            AbrirConexionJDBC();
            Statement stmt = null;
            stmt = connection.createStatement();
            String local = "";
            //ya que tenemos el usuario seleccionado con nuestro password procedemos a acutalizarlo
            local = lista.cambiar2 + "'" + antiguo + "','" + clave1 + "','" + nombre + "'";
            stmt.execute(local);

            stmt.close();
            CerrraConexionJDBC();
            return true;
        } catch (Exception xss) {
            System.out.println(xss.getMessage());
            return false;
        }
    }

    public boolean insertDepartamento(String NomDepto, HttpServletResponse response, Error_Data misErrores) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Departamento miDepto = new Departamento();
            miDepto.setNombre(NomDepto);
            misessionFactory.getCurrentSession().save(miDepto);
            //si todo estubo bien realizamos el commit
            realizarCommit(mitransaction);

        } catch (Exception xs) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }            //mostramaos el error en la pantalla del usuario
            try {
                misErrores.EscribirMensajes(xs.getMessage(), response, "Regresar", "Departamento_Nuevo.jsp");
            } catch (IOException ex) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
                System.out.println(ex.getMessage());
            }
            System.out.println("---- ---- ---- en metodo insertDepartamento " + xs.getMessage());
            return false;
        }

        return true;
    }

    /***
     * ingresa un usuario nuevo para verficara logeo del usuario en nuestra aplicacion
     * por medio de hibernate
     * 0----no logeado
     * 1----esta logeado utilizando la aplicacion
     * retorna true si todo salio bien
     * trae ademas usuarioNuevo que =login de la aplicacion
     **/
    private boolean insertUser_Log(Object var, String usuarioNuevo, HttpServletResponse response, Error_Data misErrores, String tip) {
        try {

            //iniciamos la transaccion
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            UserLog miusuario = new UserLog();
            miusuario.setIdUserLog(usuarioNuevo);//el usuario nuevo
            miusuario.setAdentro(new Byte("0"));//no logeado

            if (tip.compareTo("cliente") == 0) {
                miusuario.setCliente((Cliente) var);
                miusuario.setEmpleado(null);

            } else if (tip.compareTo("empleado") == 0) {
                miusuario.setEmpleado((Empleado) var);
                miusuario.setCliente(null);
            }

            misessionFactory.getCurrentSession().save(miusuario);
            //si todo estubo bien realizamos el commit
            realizarCommit(mitransaction);


        } catch (Exception xs) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }            //mostramaos el error en la pantalla del usuario
            try {
                misErrores.EscribirMensajes(xs.getMessage(), response, "Regreso", "Usuario_Nuevo.jsp");
            } catch (IOException ex) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
                System.out.println(ex.getMessage());
            }
            System.out.println("........................... en el metodo insertUserLog" + xs.getMessage());
            return false;
        }

        return true;
    }

    /***
     * verificara de que tipo es el usuario si es
     * cliente o sie es empleado y lo ingresara a la base x medio de hibernate
     * y si tiene algunos errores lo mostrar como repetidos o algo violado
     ****/
    private boolean verificarTipoUsuario(String usuarioNuevo, String[] matris, HttpServletResponse response, Error_Data misErrores, Tipo[] param) {
        /***
         * tiene el tipo de usario que se va a insertar
         **/
        Comparacion mi = new Comparacion();
        String tip = mi.tipo_de_usuario_insercion_modelo(matris);
        try {

            //iniciamos la transaccion
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            Object var = null;
            if (tip.compareTo("cliente") == 0) {
                Cliente micliente = new Cliente();
                micliente = mi.asignardatoscliente(micliente, param);
                misessionFactory.getCurrentSession().save(micliente);//guradmaos el cliente
                var = micliente;
            } else if (tip.compareTo("empleado") == 0) {
                Empleado miempleado = new Empleado();
                miempleado = mi.asignardatosempleado(miempleado, param);
                misessionFactory.getCurrentSession().save(miempleado);//guardamos el empleado
                var = miempleado;
            }


            //ahorita vamos a terminar la transaccion realizamos un comiiit
            realizarCommit(mitransaction);

            //ahora insertamos el log de un usuario nuevo
            boolean realizar = insertUser_Log(var, usuarioNuevo, response, misErrores, tip);
            return realizar;


        } catch (Exception xs) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }
            //mostramaos el error en la pantalla del usuario
            try {
                misErrores.EscribirMensajes(xs.getMessage(), response, "Regreso", "Usuario_Nuevo.jsp");
            } catch (IOException ex) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
                return false;
            }
            System.out.println("........................... en el metodo insertUserLog" + xs.getMessage());
            return false;
        }

    }

    /**
     * realiza la eliminacion de un la tabla userlog cuando
     * se elimina el usario web 
     ***/
    private boolean eliminar_usuario_Tabla_userlog(String nombre, String tipo, String eliminar) {
        //iniciamos la transaccion
        mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
        try {
            Query resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where IdUserLog='" + nombre + "'");
            List milista = resultado.list();
            while (!milista.isEmpty()) {
                misessionFactory.getCurrentSession().delete(milista.remove(0));
                break;
            }

            //si solo si es de tipo cliente el que se esta eliminando
            if (tipo.compareTo("Cliente") == 0) {
                //ahora buscamos en la tabla cliente el que coincida y lo elimnamos
                resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where Nombre='" + eliminar + "'");
                milista = resultado.list();
                while (!milista.isEmpty()) {
                    //si no esta vacia buscamos la conincidencia
                    Cliente mi = (Cliente) milista.remove(0);
                    misessionFactory.getCurrentSession().delete(mi);
                    break;
                }
            } else if (tipo.compareTo("Empleado") == 0) {
                //ahora buscamos en la tabla cliente el que coincida y lo elimnamos
                resultado = misessionFactory.getCurrentSession().createQuery("from Empleado where Nombre='" + eliminar + "'");
                milista = resultado.list();
                while (!milista.isEmpty()) {
                    //si no esta vacia buscamos la conincidencia
                    Empleado mi = (Empleado) milista.remove(0);
                    misessionFactory.getCurrentSession().delete(mi);
                    break;
                }
            }


            //ahorita vamos a terminar la transaccion realizamos un comiiit
            realizarCommit(mitransaction);
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            return false;
        }
        return true;
    }

    /***
     * regresa la lista de nombres solo de nombres ya sea
     * de la tabla cliente o la de empleado
     * el parametro es el nombre de la tabla que desamos recibir
     * el resultado contiene tags HTML......
     **/
    private String Regresa_listas(String tabla) {
        String res = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from " + tabla);
            List milista = resultado.list();
            if (tabla.compareTo("Cliente") == 0) {
                while (!milista.isEmpty()) {
                    //obtenemos todos los nombres de la tabla
                    Cliente mi = (Cliente) milista.remove(0);
                    res += "<option value=\"" + mi.getNombre() + "\">" + mi.getNombre() + "</option>";
                }
            } else if (tabla.compareTo("Empleado") == 0) {
                while (!milista.isEmpty()) {
                    //obtenemos todos los nombres de la tabla
                    Empleado mi = (Empleado) milista.remove(0);
                    res += "<option value=\"" + mi.getNombre() + "\">" + mi.getNombre() + "</option>";
                }
            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    /***
     * regresa los datos del cliente
     ***/
    public String[] regresarCliente_editar(String nombre1) {
        String res[] = new String[3];
        res[0] = "";
        res[1] = "";
        res[2] = "";

        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where Nombre='" + nombre1 + "'");
            List milista = resultado.list();
            Comparacion nueva = new Comparacion();

            while (!milista.isEmpty()) {
                Cliente mi = (Cliente) milista.remove(0);
                res[2] += mi.getIdCliente();//el id que identifica
                res[0] += nueva.regresarEtiquetaHTML(mi.getDireccion(), "direccion");
                //res[0]+=nueva.regresarEtiquetaHTML(mi.getFoto(),"foto");
                //res[0]+=nueva.regresarEtiquetaHTML(mi.getFirma(),"firma");
                res[0] += nueva.regresarEtiquetaHTML(mi.getMail(), "mail");
                res[0] += nueva.regresarEtiquetaHTML(mi.getTelefono(), "telefono");
                //ahora realizamos otra consulta haber si tiene asignado un valor de usuario web
                Query resultado1 = misessionFactory.getCurrentSession().createQuery("from UserLog where Cliente_idCliente=" + mi.getIdCliente());
                List milista1 = resultado1.list();
                while (milista1.isEmpty()) {
                    res[1] += "<br> Desea agregar un usuario web"
                            + "<li><label>name"
                            + "<input name=\"nombre\""
                            + "type=\"text\" size=32/>"
                            + "</label></li>"
                            + "<li><label>password1"
                            + "<input name=\"password1\""
                            + "type=\"password\" size=32/>"
                            + "</label></li>"
                            + "<li><label>password2"
                            + "<input name=\"password2\""
                            + "type=\"password\" size=32/>"
                            + "</label></li>"
                            + " <INPUT type=\"checkbox\" name=\"agregar\" value=\"agregar\">Si deseo Agregar el usuario web ";
                    break;
                }


            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    /***
     * regresa solo los campos necesarios para modificar la fotografia y la firma del cliente
     *
     ****/
    public String[] regresarCliente_editar_Fotografias(String nombre1) {
        String res[] = new String[3];
        res[0] = "";
        res[1] = "";
        res[2] = "";

        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where Nombre='" + nombre1 + "'");
            List milista = resultado.list();
            Comparacion nueva = new Comparacion();

            while (!milista.isEmpty()) {
                Cliente mi = (Cliente) milista.remove(0);
                res[2] += mi.getNombre();//el id que identifica
                //res[0]+=nueva.regresarEtiquetaHTML(mi.getDireccion(),"direccion");
                res[0] += nueva.regresarEtiquetaHTML(mi.getFoto(), "foto");
                res[0] += nueva.regresarEtiquetaHTML(mi.getFirma(), "firma");
                //res[0]+=nueva.regresarEtiquetaHTML(mi.getMail(),"mail");
                //res[0]+=nueva.regresarEtiquetaHTML(mi.getTelefono(),"telefono");
                //ahora realizamos otra consulta haber si tiene asignado un valor de usuario web
                // Query resultado1=misessionFactory.getCurrentSession().createQuery("from UserLog where Cliente_idCliente="+mi.getIdCliente());
                // List milista1=resultado1.list();
                    /* while(milista1.isEmpty())
                {
                res[1]+="<br> Desea agregar un usuario web"
                + "<li><label>name"+
                "<input name=\"nombre\""+
                "type=\"text\" size=32/>"+
                "</label></li>"
                +"<li><label>password1"
                + "<input name=\"password1\""+
                "type=\"password\" size=32/>"+
                "</label></li>"
                +"<li><label>password2"
                +"<input name=\"password2\""+
                "type=\"password\" size=32/>"+
                "</label></li>"
                +" <INPUT type=\"checkbox\" name=\"agregar\" value=\"agregar\">Si deseo Agregar el usuario web ";
                break;
                }*/


            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    public boolean actualizardatosCliente(Tipo[] param, String miid) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where idCliente=" + miid);
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //si no esta vacia
                //datos tomados del dopost de editarcleite_aux.java
                Cliente mi = (Cliente) milista.remove(0);
                if (param[0].getvalor() != null)//direccion
                {
                    mi.setDireccion(param[0].getvalor());
                }
                // if((param[1].getvalor() == null ? "" != null : !param[1].getvalor().equals("")))//foto
                //   mi.setFoto(param[1].getvalor());
                //if((param[1].getvalor() == null ? "" != null : !param[1].getvalor().equals("")))//firma
                //   mi.setFirma(param[2].getvalor());
                if (param[3].getvalor() != null)//mail
                {
                    mi.setMail(param[3].getvalor());
                }
                if (param[4].getvalor() != null)//telefono
                {
                    mi.setTelefono(param[4].getvalor());
                }
                //ahora actualizamos los datos

                misessionFactory.getCurrentSession().update(mi);


            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
            return false;
        }
        return true;
    }

    public boolean actualizardatosEmpleado(Tipo[] param, String miid) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Empleado where idEmpleado=" + miid);
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //si no esta vacia
                //datos tomados del dopost de editarcleite_aux.java
                Empleado mi = (Empleado) milista.remove(0);
                if (param[0].getvalor() != null)//direccion
                {
                    mi.setDireccion(param[0].getvalor());
                }
                if (param[1].getvalor() != null)//mail
                {
                    mi.setMail(param[1].getvalor());
                }
                if (param[2].getvalor() != null)//telefono
                {
                    mi.setTelefono(param[2].getvalor());
                }
                //ahora actualizamos los datos

                misessionFactory.getCurrentSession().update(mi);


            }

            realizarCommit(mitransaction);

        } catch (Exception ex) {
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
            return false;
        }
        return true;
    }

    /***
     * crea un usuario web siempre y cuando sea cliente ya que este
     * alla sido eliminado por la aplicacion el cliente ya existe
     ****/
    public boolean CrearUsuarioWEB_(String usuarioNuevo, String passwords, HttpServletResponse response, Error_Data misErrores, String id) {
        try {
            Querys nuevo = new Querys();
            AbrirConexionJDBC();
            Statement stmt = null;
            stmt = connection.createStatement();
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //cominezo de la transaccion
            stmt.execute("begin tran");
            //creamos el usuario dependiendo de donde es asignado si es gerente o otro
            String local = "";


            local = nuevo.crear_Login_nombre + usuarioNuevo + nuevo.crear_Login_Password + passwords + "' ,DEFAULT_DATABASE=[mibase];";//nuevo.crear_Login_Base;

            stmt.execute(local);
            //lo agregamos a un grupo en especifico
            local = nuevo.crear_usuario_nombre + usuarioNuevo + nuevo.crear_for_login + usuarioNuevo + ";";
            stmt.execute(local);
            //ahora verificamos en que rol nos pertenece
            String matris[] = {""};
            local = verificarRolSeleccionado(matris, usuarioNuevo);
            stmt.execute(local);

            //ahora lo agregamos a nuestro userlog x que ya existe un
            //var tiene un objeto cliente del id seleccionado
            Object var = regresaClienteseleccionado(id);
            boolean todo_bien = insertUser_Log(var, usuarioNuevo, response, misErrores, "cliente");
            //hasta este momemto se creo el user y el login en nuestra base de datos
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------
            //-------------------------------------------------------------------------------------------------------------------------

            if (todo_bien)//entonces realizamos el commit
            {
                stmt.execute("commit tran");
            } else//si algo esta malo entonces realizamos el rollback a nuestra base de datos
            {
                stmt.execute("rollback tran");
            }

            //insertamso ya sea si es cliente o empleado dependiendo de la tabla
            //ahora ya tenemos el usuario y el cliente o empleado solo falta realacionarlo

            stmt.close();
            CerrraConexionJDBC();//esta conexion se la cerramos y abrimos cada vez que la necesitemos

            /****
             * si algo sucedio y esta malo entonces debemos de borrar
             **/
            if (todo_bien == false) {
                //a ocurrido un error ingrese de nuevo los datos
                return false;
            }

        } catch (Exception ex) {
            try {
                System.out.println(ex.getMessage());
                misErrores.EscribirMensajes(ex.getMessage(), response, "Regresar", "Editar_Cliente.jsp");
                return false;
            } catch (IOException ex1) {
                Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex1);
            }
        }

        return true;
    }

    private Object regresaClienteseleccionado(String id) {
        //por medio de hibernate
        Object var = null;
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where idCliente=" + id);
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                var = milista.remove(0);
            }
            realizarCommit(mitransaction);
        } catch (Exception ex) {
            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
            return var;
        }
        return var;
    }

    /***
     * devuelve solo los clientes
     **/
    private LinkedList devolverlista_clientelogs() {
        mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
        Query resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where Cliente_idCliente!=null");
        List milista = resultado.list();
        LinkedList<String> retorna = new LinkedList<String>();
        for (Iterator it = milista.iterator(); it.hasNext();) {
            UserLog userLog = (UserLog) it.next();
            retorna.add(userLog.getIdUserLog());
        }

        realizarCommit(mitransaction);
        return retorna;
    }

    /***
     * regresa los datos del operador
     ***/
    public String[] regresarOperador_editar(String nombre1) {
        String res[] = new String[3];
        res[0] = "";
        res[1] = "";
        res[2] = "";

        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Empleado where Nombre='" + nombre1 + "'");
            List milista = resultado.list();
            Comparacion nueva = new Comparacion();

            while (!milista.isEmpty()) {
                Empleado mi = (Empleado) milista.remove(0);
                res[2] += mi.getIdEmpleado();//el id que identifica
                res[0] += nueva.regresarEtiquetaHTML(mi.getDireccion(), "direccion");
                res[0] += nueva.regresarEtiquetaHTML(mi.getMail(), "mail");
                res[0] += nueva.regresarEtiquetaHTML(mi.getTelefono(), "telefono");
            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    /**
     * regresa el objeto departamento con el nombre que tiene valor
     **/
    Departamento regrasarDepartamento_Objeto(String valor) {
        Departamento mi = null;
        try {

            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento where Nombre='" + valor + "'");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                mi = (Departamento) milista.remove(0);
            }


        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            return mi;
        }

        return mi;
    }

    /*int regrasarDepartamento_Objeto_id(String valor) {
    int mi = 0;
    try {

    Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento where ='" + valor + "'");
    List milista = resultado.list();

    while (!milista.isEmpty()) {
    mi = ((Departamento) milista.remove(0)).getIdDepartamento();
    }


    } catch (Exception ex) {
    System.out.println(ex.getMessage());
    return mi;
    }

    return mi;
    }*/
    public String regresa_login(String eliminar) {
        //primero buscamos el id del cliente con este nombre
        mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
        Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente where Nombre='" + eliminar + "'");
        List milista = resultado.list();
        while (!milista.isEmpty()) {
            Cliente mi = (Cliente) milista.remove(0);
            int t = mi.getIdCliente();//el id que identifica
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where Cliente_idCliente='" + t + "'");
            List milista2 = resultado.list();
            while (!milista2.isEmpty()) {
                UserLog ms = (UserLog) milista2.remove(0);
                return ms.getIdUserLog();
            }

        }

        realizarCommit(mitransaction);
        return null;
    }

    public String regresa_login_Empleado(String eliminar) {
        mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
        Query resultado = misessionFactory.getCurrentSession().createQuery("from Empleado where Nombre='" + eliminar + "'");
        List milista = resultado.list();
        while (!milista.isEmpty()) {
            Empleado mi = (Empleado) milista.remove(0);
            int t = mi.getIdEmpleado();//el id que identifica
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where Empleado_idEmpleado='" + t + "'");
            List milista2 = resultado.list();
            while (!milista2.isEmpty()) {
                UserLog ms = (UserLog) milista2.remove(0);
                return ms.getIdUserLog();
            }

        }

        realizarCommit(mitransaction);
        return null;
    }

    /***
     * regresa una tabla de todas las transacciones realizadas 
     **/
    public String regresar_auditoriaTotal() {
        String r = "<center>Resultado de Auditoria Total</center>" + cabecera_tablahtml1;

        try {

            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion");
            Iterator milista = resultado.list().iterator();


            while (milista.hasNext()) {
                r += "<tr>";//inicio de la fila
                Transaccion mi = (Transaccion) milista.next();

                r += "<td>" + String.valueOf(mi.getIdTransaccion()) + "</td>";
                r += "<td>" + ((Empleado) mi.getEmpleado()).getNombre() + "</td>";
                r += "<td>" + ((Descripcion) mi.getDescripcion()).getDescripcion() + "</td>";
                Cuenta xmi = (Cuenta) mi.getCuenta();
                r += "<td>" + xmi.getIdCuenta() + "</td>";
                r += "<td>" + mi.getFecha() + "</td>";
                r += "<td>" + mi.getClasTransac() + "</td>";
                r += "<td>" + mi.getValor() + "</td>";
                r += "<td>" + mi.getSaldoInicial() + "</td>";
                r += "<td>" + mi.getSaldoFinal() + "</td>";
                r += "<td>" + mi.getEstado() + "</td>";
                r += "</tr>";//fin de la fila
            }
            r += "</tbody></table><br><br>";

        } catch (Exception ex) {
            String s = ex.getMessage();
            System.out.println(s);
            return "<center>Resultado de Auditoria Total</center><HR width=\"120%\">A ocurrido un error";
        }
        return r;
    }

    /***
     * regresa una tabla de las transacciones realizadas en las fecha indicadas
     ***/
    public String regresar_auditoriaTotal(String fecha1, String fecha2) {
        String r = "<center>Resultado de Auditoria Parcial entre dos fechas</center>" + cabecera_tablahtml1;

        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion where fecha>='" + fecha1 + "' and fecha<='" + fecha2 + "'");

            Iterator milista = resultado.list().iterator();


            while (milista.hasNext()) {
                r += "<tr>";//inicio de la fila
                Transaccion mi = (Transaccion) milista.next();

                r += "<td>" + String.valueOf(mi.getIdTransaccion()) + "</td>";
                r += "<td>" + ((Empleado) mi.getEmpleado()).getNombre() + "</td>";
                r += "<td>" + ((Descripcion) mi.getDescripcion()).getDescripcion() + "</td>";
                Cuenta xmi = (Cuenta) mi.getCuenta();
                r += "<td>" + xmi.getIdCuenta() + "</td>";
                r += "<td>" + mi.getFecha() + "</td>";
                r += "<td>" + mi.getClasTransac() + "</td>";
                r += "<td>" + mi.getValor() + "</td>";
                r += "<td>" + mi.getSaldoInicial() + "</td>";
                r += "<td>" + mi.getSaldoFinal() + "</td>";
                r += "<td>" + mi.getEstado() + "</td>";
                r += "</tr>";//fin de la fila
            }
            r += "</tbody></table><br><br>";

        } catch (Exception ex) {
            String m = ex.getMessage();
            System.out.println(m);
            return "<center>Resultado de Auditoria Parcial entre dos fechas</center>"
                    + "<HR width=\"120%\">" + "A ocurrido un Error en el ingreso de fechas intentelo de nuevo";
        }



        return r;
    }

    /***
     * regresa la auditoria del cliente especifico que se ubico en sus cuentas
     ***/
    public String regresar_auditoriaTotal(String nombre_cliente, boolean valido, String fecha1, String fecha2) {
        String r = "<center>Resultado de Auditoria Parcial de un cliente especifico<br>"
                + "nombre del cliente: " + nombre_cliente + "</center>" + cabecera_tablahtml1;

        try {
            Query resultado = null;
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            if (valido) {
                String consulta1 = "(select idCliente from Cliente where nombre='" + nombre_cliente + "')";
                resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion where Cuenta_Cliente_idCliente=" + consulta1 + "and fecha>='" + fecha1 + "' and fecha<='" + fecha2 + "'");

            } else//solo nombre
            {
                String consulta1 = "(select idCliente from Cliente where nombre='" + nombre_cliente + "')";
                resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion where Cuenta_Cliente_idCliente=" + consulta1);

            }
            Iterator milista = resultado.list().iterator();

            while (milista.hasNext()) {

                r += "<tr>";//inicio de la fila
                Transaccion mi = (Transaccion) milista.next();

                r += "<td>" + String.valueOf(mi.getIdTransaccion()) + "</td>";
                r += "<td>" + ((Empleado) mi.getEmpleado()).getNombre() + "</td>";
                r += "<td>" + ((Descripcion) mi.getDescripcion()).getDescripcion() + "</td>";
                Cuenta xmi = (Cuenta) mi.getCuenta();
                r += "<td>" + xmi.getIdCuenta() + "</td>";
                r += "<td>" + mi.getFecha() + "</td>";
                r += "<td>" + mi.getClasTransac() + "</td>";
                r += "<td>" + mi.getValor() + "</td>";
                r += "<td>" + mi.getSaldoInicial() + "</td>";
                r += "<td>" + mi.getSaldoFinal() + "</td>";
                r += "<td>" + mi.getEstado() + "</td>";
                r += "</tr>";//fin de la fila*/
            }
            r += "</tbody></table><br><br>";

        } catch (Exception ex) {
            String m = ex.getMessage();
            System.out.println(m);
            return "<center>Resultado de Auditoria Parcial entre dos fechas</center>"
                    + "<HR width=\"120%\">" + "A ocurrido un Error en el ingreso de fechas intentelo de nuevo";
        }

        return r;
    }

    /***
     * regresa la auditoria del cliente especifico por tipo de transaccion
     ***/
    public String regresar_auditoriaTotal(String tipo) {
        String r = "<center>Resultado de Auditoria Parcial por tipo de transaccion<br>"
                + "</center>" + cabecera_tablahtml1;

        try {
            Query resultado = null;
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion where clas_transac='" + tipo + "'");

            Iterator milista = resultado.list().iterator();
            while (milista.hasNext()) {

                r += "<tr>";//inicio de la fila
                Transaccion mi = (Transaccion) milista.next();

                r += "<td>" + String.valueOf(mi.getIdTransaccion()) + "</td>";
                r += "<td>" + ((Empleado) mi.getEmpleado()).getNombre() + "</td>";
                r += "<td>" + ((Descripcion) mi.getDescripcion()).getDescripcion() + "</td>";
                Cuenta xmi = (Cuenta) mi.getCuenta();
                r += "<td>" + xmi.getIdCuenta() + "</td>";
                r += "<td>" + mi.getFecha() + "</td>";
                r += "<td>" + mi.getClasTransac() + "</td>";
                r += "<td>" + mi.getValor() + "</td>";
                r += "<td>" + mi.getSaldoInicial() + "</td>";
                r += "<td>" + mi.getSaldoFinal() + "</td>";
                r += "<td>" + mi.getEstado() + "</td>";
                r += "</tr>";//fin de la fila*/
            }
            r += "</tbody></table><br><br>";

        } catch (Exception ex) {
            String m = ex.getMessage();
            System.out.println(m);
            return "<center>Resultado de Auditoria Parcial entre dos fechas</center>"
                    + "<HR width=\"120%\">" + "A ocurrido un Error en el ingreso de fechas intentelo de nuevo";
        }

        return r;
    }

    public String Regresa_Cliente() {
        String res = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cliente");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //obtenemos todos los nombres de la tabla
                Cliente mi = (Cliente) milista.remove(0);
                res += "<option value=\"" + mi.getIdCliente() + "\">" + mi.getNombre() + "</option>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    public byte verificar_logueo(String usuario) {
        try {

            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where idUserLog='" + usuario + "'");
            ArrayList milista = (ArrayList) resultado.list();

            this.realizarCommit(mitransaction);
            if (milista.size() == 1) {
                return ((UserLog) milista.get(0)).getAdentro();
            } else {
                return 1;
            }

        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            return 1;
        }
    }

    public boolean cambiarLoguin(String usuario) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where idUserLog='" + usuario + "'");
            List milista = resultado.list();
            //Session si = misessionFactory.getCurrentSession();
            //mitransaction = iniciarTransaccion(si);
            //si.clear();

            UserLog ul = (UserLog)milista.get(0);
            ul.setAdentro(new Byte("1"));

            misessionFactory.getCurrentSession().update(ul);

            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }
            System.out.println("no se hizo el update en cambiar Loguin -----" + ex.getMessage());
            return false;
        }
    }

    public boolean eliminarLogueado(String usuario) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from UserLog where idUserLog='" + usuario + "'");
            List milista = resultado.list();
            //Session si = misessionFactory.getCurrentSession();
            //mitransaction = iniciarTransaccion(si);
            //si.clear();

            UserLog ul = (UserLog)milista.get(0);
            ul.setAdentro(new Byte("0"));

            misessionFactory.getCurrentSession().update(ul);

            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }
            System.out.println("no se hizo el update en cambiar Loguin -----" + ex.getMessage());
            return false;
        }
    }

    public boolean EliminarCuenta(String cuenta) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuenta + "'");
            List milista = resultado.list();

            Cuenta m = (Cuenta) milista.get(0);

            misessionFactory.getCurrentSession().delete(m);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Eliminar Cuenta ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean EditarCuenta(String cuenta, String estado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuenta + "'");
            List milista = resultado.list();

            Cuenta m = (Cuenta) milista.get(0);

            m.setEstado(estado);
            misessionFactory.getCurrentSession().update(m);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Editar Cuenta ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean DarCheques(String cuenta, int cant) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuenta + "'");
            List milista = resultado.list();

            Cuenta m = (Cuenta) milista.get(0);

            Chequera nueva = new Chequera();

            nueva.setCuenta(m);
            nueva.setCantidadCheque(cant);

            misessionFactory.getCurrentSession().save(nueva);


            for (int i = 0; i < cant; i++) {
                Cheque nuevo = new Cheque();
                nuevo.setChequera(nueva);
                nuevo.setEstado("Emitido");

                ChequeId n = new ChequeId();
                n.setIdCheque(i);
                n.setChequeraIdChequera(nueva.getIdChequera());

                nuevo.setId(n);
                //nuevo.setMonto(null);
                misessionFactory.getCurrentSession().save(nuevo);
            }



            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo DarCheque ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean EditarCheque(String cuenta, String chequera, String cheque, String estado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("From Cuenta,Cliente,Chequera,Cheque Where Cliente_idCliente = idCliente AND idCuenta = Cuenta_idCuenta AND IdChequera = Chequera_IdChequera AND idCuenta = " + cuenta + " AND idCheque = " + cheque + " AND idChequera = " + chequera);
            //resultado.addScalar("c.idConduccion", Hibernate.INTEGER);
            //resultado.addScalar("c.informacion", Hibernate.STRING);


            List milista = resultado.list();

            Object[] m = (Object[]) milista.get(0);

            Cheque n = (Cheque) m[3];

            n.setEstado(estado);
            misessionFactory.getCurrentSession().update(n);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Editar Cheque ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean Monetario(String cuenta, Double monto,String empleado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuenta + "'");
            List milista = resultado.list();

            Cuenta m = (Cuenta) milista.get(0);

            if (m.getEstado().equals("Activa")) {

                BigDecimal disponible = m.getDisponible();
                BigDecimal reserva = m.getReserva();

                m.setDisponible(new BigDecimal(monto + disponible.doubleValue()));
                m.setReserva(reserva);
                m.setSaldo(new BigDecimal(m.getDisponible().doubleValue() + m.getReserva().doubleValue()));


                misessionFactory.getCurrentSession().update(m);


                realizarCommit(mitransaction);
                llenar_TransaccionD(1,m,monto,empleado,"Monetario","Este es el deposito de monetario","Depositado");
                return true;
            } else {

                return false;
            }
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Monetario ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean ChequePropio(String cuentacheque, String chequera, String cheque, Double monto, String cuentadepositar,String empleado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado1 = misessionFactory.getCurrentSession().createQuery("FROM Cuenta, Chequera, Cheque"
                    + " WHERE idCuenta = Cuenta_idCuenta"
                    + " AND idChequera = Chequera_idChequera"
                    + " AND idCuenta = " + cuentacheque + " "
                    + " AND idChequera = " + chequera + " "
                    + " AND idCheque = " + cheque);
            Query resultado2 = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuentadepositar + "'");

            List milista = resultado1.list();
            List milista2 = resultado2.list();

            Object[] ma = (Object[]) milista.get(0);

            Cuenta cuch = (Cuenta) ma[0];
            Chequera chr = (Chequera) ma[1];
            Cheque ch = (Cheque) ma[2];

            Cuenta cudep = (Cuenta) milista2.get(0);

            if (cuch.getEstado().equals("Activa") && cudep.getEstado().equals("Activa")) {

                BigDecimal disponible = cuch.getDisponible();
                if ((disponible.doubleValue() - monto) > 0) {
                    cuch.setDisponible(new BigDecimal(disponible.doubleValue() - monto));
                    cuch.setSaldo(new BigDecimal(cuch.getDisponible().doubleValue() + cuch.getReserva().doubleValue()));

                    BigDecimal disp = cudep.getDisponible();
                    cudep.setDisponible(new BigDecimal(disp.doubleValue() + monto));
                    cudep.setSaldo(new BigDecimal(cudep.getDisponible().doubleValue() + cudep.getReserva().doubleValue()));

                    ch.setEstado("Depositado");
                    ch.setMonto(new BigDecimal(monto));


                    misessionFactory.getCurrentSession().update(cuch);
                    misessionFactory.getCurrentSession().update(ch);

                    misessionFactory.getCurrentSession().update(cudep);

                    realizarCommit(mitransaction);
                    llenar_TransaccionCP(1,cuch,cudep,monto,empleado,"ChequePropio","Este es el deposito de un cheque del mismo banco","Depositado");
                    return true;
                } else {
                    return false;
                }

            } else {
                return false;
            }
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo ChequesPropios ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean CrearBanco(String nombre, String dir, String tel) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            // Query resultado=misessionFactory.getCurrentSession().createQuery("from Cliente where idCliente='"+usuarioNuevo+"'");
            // List milista=resultado.list();

            // Cliente m = (Cliente) milista.get(0);

            Banco n = new Banco();
            n.setNombre(nombre);
            n.setDireccion(dir);
            n.setTelefono(tel);

            misessionFactory.getCurrentSession().save(n);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            realizarRollback(mitransaction);
            System.err.println("Error en el Metodo CrearCuenta ------- " + ex.getMessage());
            return false;
        }
    }

    public String Regresa_Banco() {
        String res = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                //obtenemos todos los nombres de la tabla
                Banco mi = (Banco) milista.remove(0);
                res += "<option value=\"" + mi.getIdBanco() + "\">" + mi.getNombre() + "</option>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }

    public boolean EliminarBanco(String banco) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco where idBanco='" + banco + "'");
            List milista = resultado.list();

            Banco m = (Banco) milista.get(0);

            misessionFactory.getCurrentSession().delete(m);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Eliminar Banco ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean EditarBanco(String nombre, String dir, String tel) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco where idBanco='" + nombre + "'");
            List milista = resultado.list();

            Banco m = (Banco) milista.get(0);
            m.setNombre(nombre);
            m.setDireccion(dir);
            m.setTelefono(tel);
            misessionFactory.getCurrentSession().update(m);


            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo Eliminar Banco ------- " + ex.getMessage());
            return false;
        }
    }

    public String regresarTodoslosnombresbancosexistentes() {
        String valor = "";
        try {

            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco");
            List milista = resultado.list();

            realizarCommit(mitransaction);

            return valor;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error al ver los nombres de los bancos------ " + ex.getMessage());
            return valor;
        }
    }

    public String obtenerSeleccionDepartamentos() {
        String resultado = "";
        try {
            AbrirConexionJDBC();
            Statement stmt = null;
            stmt = connection.createStatement();

            ResultSet a = stmt.executeQuery("Select nombre from Departamento");

            while (a.next()) {
                resultado += "<option value=\"" + a.getString(1) + "\">" + a.getString(1) + "</option>";
            }

            stmt.close();
            CerrraConexionJDBC();

        } catch (SQLException ex) {
            System.out.println("metodo obtenerSeleccionDepartamento:" + ex.getMessage());
        }
        return resultado;
    }

    public boolean insertSucursal(String nombreSucursal, String dirSucursal, String telSucursal, String iddeptoSucursal, HttpServletResponse response, Error_Data misErrores) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Departamento where idDepartamento='" + iddeptoSucursal + "'");
            List milista = resultado.list();

            Departamento m = (Departamento) milista.get(0);

            Sucursal miSucursal = new Sucursal();
            miSucursal.setNombre(nombreSucursal);
            miSucursal.setDireccion(dirSucursal);
            miSucursal.setTelefono(telSucursal);
            miSucursal.setDepartamento(m);
            misessionFactory.getCurrentSession().save(miSucursal);
            //si todo estubo bien realizamos el commit
            realizarCommit(mitransaction);

        } catch (Exception xs) {
            if (mitransaction != null)//siempre y cuando no sea igual a null y se alla reservado memoria para el objeto
            {
                realizarRollback(mitransaction);//regresamos al punto inicial
            }            //mostramaos el error en la pantalla del usuario
            System.out.println("---- ---- ---- en metodo insertSucursal " + xs.getMessage());
            return false;
        }

        return true;
    }

    public boolean EditarSucursal_H(String edit_id_sucursal, String edit_nombre, String edit_direccion, String edit_telefono, String edit_iddepartamento) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Sucursal where idSucursal='" + edit_id_sucursal + "'");
            List milista = resultado.list();
            Sucursal sucu = (Sucursal) milista.get(0);

            Query resultado1 = misessionFactory.getCurrentSession().createQuery("from Departamento where idDepartamento='" + edit_iddepartamento + "'");
            List milista1 = resultado1.list();

            Departamento m = (Departamento) milista1.get(0);

            sucu.setNombre(edit_nombre);
            sucu.setDireccion(edit_direccion);
            sucu.setTelefono(edit_telefono);
            sucu.setDepartamento(m);
            misessionFactory.getCurrentSession().update(sucu);
            realizarCommit(mitransaction);

            return true;
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error: en Editarsucursal_H .... " + ex.getMessage());
            return false;
        }
    }

    public String regresarSucursalxdepartamento(String depart) {
        String t = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Sucursal where Departamento_idDepartamento=" + depart);
            List milista = resultado.list();

                for (Iterator it = milista.iterator(); it.hasNext();) {
                    Sucursal object = (Sucursal) it.next();
                    t+="<OPTION label="+object.getNombre()+" value="+object.getIdSucursal()+">"+object.getNombre();
                }

            for (Iterator it = milista.iterator(); it.hasNext();) {
                Sucursal object = (Sucursal) it.next();
                t += "<OPTION label=" + object.getIdSucursal() + " value=" + object.getIdSucursal() + ">" + object.getNombre();
            }

            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
        }

        return t;
    }

    //lo modifique ayer
    Sucursal reg_sucursal_id(String valor) {
        Sucursal t = null;
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Sucursal where idSucursal=" + valor);
            List milista = resultado.list();
            for (Iterator it = milista.iterator(); it.hasNext();) {
                Sucursal object = (Sucursal) it.next();
                return object;//regresar el departametno
            }
            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
        }

        return t;
    }

    public String regresarBancosTransaccionPendientes_compesar() {
        String t = " <form action=\"<%=Conexion.localhost+\"NuevoUsuario\" %>\" method=\"post\" \">"
                + "<select name=bancos1";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco where idBanco in (from Transaccion where estado='pendiente_compensacion')");
            List milista = resultado.list();

            if (!milista.isEmpty()) {
                for (Iterator it = milista.iterator(); it.hasNext();) {
                    Banco object = (Banco) it.next();
                    t += "<OPTION label=" + object.getIdBanco() + " value=" + object.getIdBanco() + ">" + object.getNombre();
                }
                t += "<br>  <input type=\"submit\" value=\"GRABAR\" align=\"center\" ><br>\""
                        + "</form>";
            } else {
                //si no hay transacciones pendientes entonces mostrar un mensaje y redireccionar a la pagina principal
                t = "no hay transacciones pendientes";

            }


            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
            return "ocurrio un Error al obtener los nombres de bancos disponibles";
        }

        return t;
    }

    public void imprimirarchivosparachequescompnesacion(String id, HttpServletResponse response) {
        PrintWriter out = null;
        try {
            //ahora imprimimos los archivos para que la persona descarge el archivo
            out = response.getWriter();
            String resultado = regresarDatosparaelArchivo(id);
            response.setContentType("application/octet-stream");
            response.setHeader("Content-Disposition", "attachment;filename=" + resultado + ".txt");
            //realiamos el Query de devolvera todo los datos de las trnsacciones pendientes
            String mandar_Archivo = buscar_datos_pendiente1(id);
            out.println(mandar_Archivo);
            out.close();
        } catch (IOException ex) {
            Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            out.close();
        }

    }

    /***
     * regresra el nombre del banco y recibe como parametro el id del banco
     ***/
    private String regresarnombre_Banco(String id) {
        String regresar = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco where idBanco=" + id);
            List milista = resultado.list();

            for (Iterator it = milista.iterator(); it.hasNext();) {
                Banco object = (Banco) it.next();
                return object.getNombre();//regresar el departametno
            }
            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
        }
        return regresar;
    }

    private String buscar_datos_pendiente1(String id) {
        String res = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Transaccion where idBanco=" + id);
            List milista = resultado.list();

            for (Iterator it = milista.iterator(); it.hasNext();) {
                Transaccion object = (Transaccion) it.next();
                res += object.getDescripcion();//regresar el departametno
            }
            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
        }
        return res;
    }

    /***
     * regresar los banco para cheques compnesados
     **/
    public String regresar_ChequesCompensados() {
        String t = " <form action=\"<%=Conexion.localhost+\"NuevoUsuario\" %>\" method=\"post\" \">"
                + "<select name=bancos2";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco where idBanco in (from Transaccion where estado='pendiente_compensacion')");
            List milista = resultado.list();

            if (!milista.isEmpty()) {
                for (Iterator it = milista.iterator(); it.hasNext();) {
                    Banco object = (Banco) it.next();
                    t += "<OPTION label=" + object.getIdBanco() + " value=" + object.getIdBanco() + ">" + object.getNombre();
                }
                t += "<br>  <input type=\"submit\" value=\"GRABAR\" align=\"center\" ><br>\""
                        + "</form>";
            } else {
                //si no hay transacciones pendientes entonces mostrar un mensaje y redireccionar a la pagina principal
                t = "no hay transacciones pendientes";

            }


            realizarCommit(mitransaction);
        } catch (Exception xs) {
            System.out.println(xs.getMessage());
            return "*ocurrio un Error al obtener los nombres de bancos disponibles";
        }

        return t;
    }

    public String consultasaldos(String cuenta) {
        String res = "<tr><td>Cuenta</td><td>Saldo</td><td>Disponible</td><td>Reserva</td></tr>";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta WHERE idCuenta = " + cuenta);
            List milista = resultado.list();



            while (!milista.isEmpty()) {
                //obtenemos todos los nombres de la tabla
                Cuenta mi = (Cuenta) milista.remove(0);
                res += "<tr><td>" + mi.getIdCuenta() + "</td><td>" + mi.getSaldo() + "</td><td>" + mi.getDisponible() + "</td><td>" + mi.getReserva() + "</td></tr>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }
//        public List grafica_consultasaldos(){
//           List listadato = null;
//                try {
//            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
//            Criteria crit = misessionFactory.getCurrentSession().createCriteria(Cuenta.class);
//            ProjectionList proList = Projections.projectionList();
//            proList.add(Projections.sum("saldo"));
////            proList.add(Projections.sum("disponible"));
////            proList.add(Projections.sum("reserva"));
//
//            crit.setProjection(proList);
//            List sumResult = crit.list();
//
//
//                listadato.add(sumResult.get(0));
////                listadato.add(sumResult.get(1));
////                listadato.add(sumResult.get(2));
//             System.out.println("************************************\n");
////            System.out.println("Total Invested Amount: " + sumResult);
//
//            realizarCommit(mitransaction);
//
//        } catch (Exception ex) {
//
//            if (mitransaction != null) {
//                realizarRollback(mitransaction);
//            }
//
//            System.out.println(ex.getMessage());
//        }
//        return listadato;
//    }
    public void grafica_consultasaldos(LinkedList listadato) {

        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select SUM(saldo) as saldo,SUM(disponible) as disponible,SUM(reserva) as reserva from Cuenta");
            List milista = resultado.list();
            Object[] ma0 = (Object[]) milista.get(0);
            listadato.add(ma0);
            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
    }

    public boolean PagarCheque(String cuentacheque, String chequera, String cheque, Double monto,String empleado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado1 = misessionFactory.getCurrentSession().createQuery("FROM Cuenta, Chequera, Cheque"
                    + " WHERE idCuenta = Cuenta_idCuenta"
                    + " AND idChequera = Chequera_idChequera"
                    + " AND idCuenta = " + cuentacheque + " "
                    + " AND idChequera = " + chequera + " "
                    + " AND idCheque = " + cheque);


            List milista = resultado1.list();

            Object[] ma = (Object[]) milista.get(0);

            Cuenta cuch = (Cuenta) ma[0];
            Chequera chr = (Chequera) ma[1];
            Cheque ch = (Cheque) ma[2];



            if (cuch.getEstado().equals("Activa")) {

                BigDecimal disponible = cuch.getDisponible();
                if ((disponible.doubleValue() - monto) > 0) {
                    cuch.setDisponible(new BigDecimal(disponible.doubleValue() - monto));
                    cuch.setSaldo(new BigDecimal(cuch.getDisponible().doubleValue() + cuch.getReserva().doubleValue()));

                    ch.setEstado("Pagado");
                    ch.setMonto(new BigDecimal(monto));


                    misessionFactory.getCurrentSession().update(cuch);
                    misessionFactory.getCurrentSession().update(ch);


                    realizarCommit(mitransaction);
                    llenar_TransaccionD(1,cuch,monto,empleado,"PagoCheque","Este el pago de un Cheque","Pagado");
                    return true;
                } else {
                    return false;
                }

            } else {
                return false;
            }
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo ChequesPropios ------- " + ex.getMessage());
            return false;
        }
    }

    public boolean transferir(String cuentacheque, Double monto, String cuentadepositar,String empleado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado1 = misessionFactory.getCurrentSession().createQuery("FROM Cuenta"
                    + " WHERE idCuenta = " + cuentacheque);
            Query resultado2 = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta='" + cuentadepositar + "'");

            List milista = resultado1.list();
            List milista2 = resultado2.list();

            Object[] ma = (Object[]) milista.get(0);

            Cuenta cuch = (Cuenta) ma[0];

            Cuenta cudep = (Cuenta) milista2.get(0);

            if (cuch.getEstado().equals("Activa") && cudep.getEstado().equals("Activa")) {

                BigDecimal disponible = cuch.getDisponible();
                if ((disponible.doubleValue() - monto) > 0) {
                    cuch.setDisponible(new BigDecimal(disponible.doubleValue() - monto));
                    cuch.setSaldo(new BigDecimal(cuch.getDisponible().doubleValue() + cuch.getReserva().doubleValue()));

                    BigDecimal disp = cudep.getDisponible();
                    cudep.setDisponible(new BigDecimal(disp.doubleValue() + monto));
                    cudep.setSaldo(new BigDecimal(cudep.getDisponible().doubleValue() + cudep.getReserva().doubleValue()));



                    misessionFactory.getCurrentSession().update(cuch);

                    misessionFactory.getCurrentSession().update(cudep);

                    realizarCommit(mitransaction);
                    llenar_TransaccionCP(1,cuch,cudep,monto,empleado,"TransferenciaFondos","Esta es la transaferencia de fondos en el mismo banco","Transferido");
                    return true;
                } else {
                    return false;
                }

            } else {
                return false;
            }
        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo ChequesPropios ------- " + ex.getMessage());
            return false;
        }
    }

    public String trimagen(String cuentacheque) {
        String res = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta WHERE idCuenta = " + cuentacheque);
            List milista = resultado.list();

            Cliente cl = ((Cuenta) milista.get(0)).getCliente();

            res = cl.getFirma();

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return res;
    }
/**
 * retorna la suma total de los saldo monetario
 * de una sucursal elegida
 * @param mi
 * @param id_sucursal
 */
    public void set_grafica_saldo_monetario(LinkedList mi, String id_sucursal) {
        try{
            mitransaction=iniciarTransaccion(misessionFactory.getCurrentSession());
//            Query result = misessionFactory.getCurrentSession().createQuery("from Sucursal where idSucursal='" + id_sucursal + "'");
//            List milist= result.list();
//            Sucursal su= (Sucursal) milist.get(0);

            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select SUM(valor) as monetario from Transaccion where Sucursal_idSucursal="+id_sucursal+" and clas_transac='Monetario'");

            
            List milista = resultado.list();//.setString("id_sucu",id_sucursal).list();
            if (milista != null) {
            Object ma0 = (Object) milista.get(0);
            mi.add(ma0);
            }
            else{
            mi = null;
            }
            realizarCommit(mitransaction);


        }  catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
    }
/**
 * retorna la suma total de los saldo PagoCheque
 * de una sucursal elegida
 * @param mi
 * @param id_sucursal
 */
    public void set_grafica_saldo_pagocheque(LinkedList mi, String id_sucursal) {
            try{
            mitransaction=iniciarTransaccion(misessionFactory.getCurrentSession());
            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select SUM(valor) as monetario from Transaccion where Sucursal_idSucursal="+id_sucursal+" and clas_transac='PagoCheque'");
            List milista = resultado.list();
            if (milista != null) {
            Object ma0 = (Object) milista.get(0);
            mi.add(ma0);
            }
            else{
            mi = null;
            }
            realizarCommit(mitransaction);


        }  catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
    }
/**
 * retorna la suma total de los saldo ChequePropio
 * de una sucursal elegida
 * @param mi
 * @param id_sucursal
 */
    public void set_grafica_saldo_chequepropio(LinkedList mi, String id_sucursal) {
              try{
            mitransaction=iniciarTransaccion(misessionFactory.getCurrentSession());
            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select SUM(valor) as monetario from Transaccion where Sucursal_idSucursal="+id_sucursal+" and clas_transac='ChequePropio'");
            List milista = resultado.list();
            if (milista != null) {
            Object ma0 = (Object) milista.get(0);
            mi.add(ma0);
            }
            else{
            mi = null;
            }
            realizarCommit(mitransaction);


        }  catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
    }
/**
 * retorna la suma total de los saldo TransferenciaFondos
 * de una sucursal elegida
 * @param mi
 * @param id_sucursal
 */

    public void set_grafica_saldo_transferenciafondos(LinkedList mi, String id_sucursal) {
              try{
            mitransaction=iniciarTransaccion(misessionFactory.getCurrentSession());
            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select SUM(valor) as monetario from Transaccion where Sucursal_idSucursal="+id_sucursal+" and clas_transac='TransferenciaFondos'");
            List milista = resultado.list();
            if (milista != null) {
            Object ma0 = (Object) milista.get(0);
            mi.add(ma0);    
            }
            else{
            mi = null;   
            }


            realizarCommit(mitransaction);


        }  catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
    }
        /**
     * devolvera los datos id, monto, estado del cheque
         * con problema en compensacion
     * una lista de seleccion HTML
     */
    public String devolverTablaChequecompensacion() {
        String devolver = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            SQLQuery resultado = misessionFactory.getCurrentSession().createSQLQuery("select idCheque,Monto,Estado from Cheque where Estado='error_compensacion'");
            List milista = resultado.list();
            String id="";
            String monto="";
                    String estado="";


            while (!milista.isEmpty()) {
                Object[] ma0 = (Object[]) milista.remove(0);
                 if(ma0[0]!=null){
                  id = (String) ma0[0].toString();
                }
                else{
                id = "";
                }
                                 if(ma0[1]!=null){
                  monto = (String) ma0[1].toString();
                }
                else{
                monto = "";
                }
                                 if(ma0[2]!=null){
                  estado = (String) ma0[2].toString();
                }
                else{
                estado = "";
                }



                devolver += "<TR> <TD>" + id + "</TD><TD>" + monto +" </TD><TD>"+estado + "</TD></TR>";
            }


            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return devolver;

    }

                    /**
     * devolvera los Estados de Cuenta
     * en tabla html
     */
    public String devolverTablaEstadosCuenta() {
        String devolver = "";
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado = misessionFactory.getCurrentSession().createQuery("from Cuenta");
            List milista = resultado.list();

            while (!milista.isEmpty()) {
                Cuenta mi = (Cuenta) milista.remove(0);
                 devolver += "<TR> <TD>" + mi.getIdCuenta() + "</TD><TD>" + mi.getSaldo() +" </TD><TD>"+mi.getDisponible() + "</TD><TD>" + mi.getEstado() + "</TD><TD>" + mi.getTipo() + "</TD><TD>" + mi.getReserva() + "</TD></TR>";
            }

            realizarCommit(mitransaction);
        } catch (Exception ex) {

            if (mitransaction != null) {
                realizarRollback(mitransaction);
            }

            System.out.println(ex.getMessage());
        }
        return devolver;

    }

           


    public boolean ChequeOtros(String bancocheque, String cuentacheque, String cheque,String chequera, Double monto, String cuentadepositar,String empleado) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco WHERE idBanco = " + bancocheque);
            List milista = resultado.list();
            Banco cl = (Banco)milista.get(0);


            Query resultado1 = misessionFactory.getCurrentSession().createQuery("from Cuenta WHERE idCuenta = " + cuentadepositar);
            List milista1 = resultado1.list();
            Cuenta cl1 = (Cuenta)milista1.get(0);


            Query resultado2 = misessionFactory.getCurrentSession().createQuery("from UserLog WHERE idUserLog = '" + empleado+"'");
            List milista2 = resultado2.list();
            UserLog cl2 = (UserLog)milista2.get(0);


            Transaccion tr = new Transaccion();

            tr.setBanco(cl);
            tr.setCuenta(cl1);
            tr.setClasTransac("D_Externo_Cheque");
            tr.setCuentaClienteIdCliente(cl1.getCliente().getIdCliente());
            tr.setCuentaExterna(Integer.parseInt(cuentacheque));
            //tr.setChequeExterno(Integer.parseInt(cheque));
            //tr.setChequeraExterna(Integer.parseInt(chequera));
            
            Descripcion des = new Descripcion();
            des.setDescripcion("Transaccion de Cheques Externos");

            tr.setDescripcion(des);
            tr.setEmpleado(cl2.getEmpleado());
            tr.setEstado("pediente_compensar");
            Calendar c = Calendar.getInstance();
            tr.setFecha(c.getTime());

            tr.setSaldoFinal(cl1.getSaldo());
            tr.setSaldoInicial(cl1.getSaldo());
            
            tr.setSucursal(cl2.getEmpleado().getSucursal());
            tr.setValor(new BigDecimal(monto));

            BigDecimal reserva = cl1.getReserva();
            double reserv = reserva.doubleValue() + monto;
            cl1.setReserva(new BigDecimal(reserv));

            cl1.setSaldo(new BigDecimal(cl1.getReserva().doubleValue() + cl1.getDisponible().doubleValue()));

            misessionFactory.getCurrentSession().update(cl1);
            misessionFactory.getCurrentSession().save(des);
            misessionFactory.getCurrentSession().save(tr);

            this.realizarCommit(mitransaction);
            return true;

        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo ChequesOtros ------- " + ex.getMessage());
            return false;
        }

    }

    /***
     * este metodo sirve para cobrar cheques del mismo banco y debitar de la cuenta resolviendo asi el valor
     * del cheque
     *
     ***/
    boolean ChequePropio(String empleado_log,int numero_chequera, int numero_cheque, double valor, int cuenta) {
        try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
            Query resultado1 = misessionFactory.getCurrentSession().createQuery("FROM Cuenta, Chequera, Cheque"
                    + " WHERE idCuenta = Cuenta_idCuenta"
                    + " AND idChequera = Chequera_idChequera"
                    + " AND idCuenta = " + cuenta + " "
                    + " AND idChequera = " + numero_chequera + " "
                    + " AND idCheque = " + numero_cheque);

           
            List milista = resultado1.list();

            if(milista.isEmpty())
                return false;

            Object[] ma = (Object[]) milista.get(0);

            Cuenta cuch = (Cuenta) ma[0];
            Chequera chr = (Chequera) ma[1];
            Cheque ch = (Cheque) ma[2];


            if (cuch.getEstado().equals("Activa") ) {

                BigDecimal disponible = cuch.getDisponible();
               
                if ((disponible.doubleValue() - valor) >= 0) {
                    cuch.setDisponible(new BigDecimal(disponible.doubleValue() - valor));
                
                    cuch.setSaldo(new BigDecimal(cuch.getDisponible().doubleValue()+cuch.getReserva().doubleValue()));

                    ch.setEstado("Depositado_Compensado");
                    ch.setMonto(new BigDecimal(valor));
                    
                    //ahora agregamos una fila mas a la tabla transacciones
                    //---
                    Transaccion tr = new Transaccion();

                    Query res21 = misessionFactory.getCurrentSession().createQuery("from Banco where nombre='propio'");
                    List fs=res21.list();
                    tr.setBanco((Banco) fs.get(0));
                    
                    Query res1 = misessionFactory.getCurrentSession().createQuery("from Cuenta where idCuenta="+cuenta);
                    List xs=res1.list();
                    tr.setCuenta((Cuenta) xs.get(0));
                    tr.setClasTransac("DepositoCheque");
                    tr.setCuentaClienteIdCliente(((Cuenta)res1).getCliente().getIdCliente());
                  
                    Descripcion des = new Descripcion();
                    des.setDescripcion("Deposito de cheque");
                    tr.setDescripcion(des);

                    Query res51 = misessionFactory.getCurrentSession().createQuery("from UserLog where idUserLog='"+empleado_log +"'");
                    List xss=res51.list();
                    tr.setEmpleado((Empleado) xss.get(0));
                    
                    tr.setEstado("Realizado");
                    Calendar c = Calendar.getInstance();
                    tr.setFecha(c.getTime());

                    BigDecimal xS=((Cuenta)res1).getSaldo();
                    xS=xS.add(BigDecimal.valueOf(valor));
                    tr.setSaldoFinal(xS);
                    tr.setSaldoInicial(((Cuenta)res1).getSaldo());

                    tr.setSucursal(((Empleado) xss.get(0)).getSucursal());
                    tr.setValor(new BigDecimal(valor));
                     //guardamos la transaccion.
                     misessionFactory.getCurrentSession().save(tr);
                    
                    //---

                    misessionFactory.getCurrentSession().update(cuch);
                    misessionFactory.getCurrentSession().update(ch);

                    realizarCommit(mitransaction);
                    return true;
                } else {
                    return false;
                }

            } else {
                return false;
            }
        } catch (Exception ex) {
            if(mitransaction!=null)
            this.realizarRollback(mitransaction);

            System.err.println("Error en el Metodo ChequesPropios ------- " + ex.getMessage());
            return false;
        }
    }


    /****
     * este metodo es cuando regresa un archivo de resutaldos y modifica nuestra tabla transaccion
     * y libera la reserva de nuestros datos
     ****/

    boolean actualizarTransaccionCuenta_OperacionTransaccion(String resultado, int numero_cheque, int cuenta, int numerochequera) {
         try {

              mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());
              Query resultado1 = misessionFactory.getCurrentSession().createQuery("from cuenta where idCuenta="+cuenta);
              Cuenta x=(Cuenta) resultado1.list().get(0);
              Query resultado2 = misessionFactory.getCurrentSession().createQuery("from transaccion where Cuenta_idCuenta="+x+"and estado='pediente_compensar' "
                      + "and clasTransac='D_Externo_Cheque' and cuentaExterna="+numero_cheque);

              Transaccion se;
              se=(Transaccion) resultado2.list().get(0);

              Query resultado9 = misessionFactory.getCurrentSession().createQuery("FROM Cheque where idCheque="+numero_cheque+
                      "and Chequera_idChequera=(from chequera where idChequera="+numerochequera+"and Cuenta_idCuenta="+cuenta+")");


            if(resultado.equals("aceptado"))
            {
                
                //liberar la reserva de la cuenta
                BigDecimal total=x.getReserva().subtract(se.getValor());
                x.setReserva(total);//devitar la reserva
                x.setDisponible(x.getDisponible().add(se.getValor()));//se lo sumamos lo q quitamos de reserva se lo agregamos al disponible
                //y el saldo se queda igual

                //actualizamos el cheque
                Cheque xs=(Cheque) resultado9.list().get(0);
                xs.setEstado("cobrado");
                xs.setMonto(se.getValor());

                //busacamos la tabla transaccion y actualizamos el dato de estado
                se.setEstado("aceptado");

                misessionFactory.getCurrentSession().update(xs);//el cheque

            }else{
                //el estado de la transaccion
                se.setEstado("rechazado");


                //actualizamos el cheque
                Cheque xs=(Cheque) resultado9.list().get(0);
                xs.setEstado("Error_compensar");
                xs.setMonto(se.getValor());

                //busacamos la tabla transaccion y actualizamos el dato de estado
                se.setEstado("aceptado");

                misessionFactory.getCurrentSession().update(xs);//el cheque
            }


               misessionFactory.getCurrentSession().update(x);//cuenta
               misessionFactory.getCurrentSession().update(se);//transaccion

               //realizamos el commit
               this.realizarCommit(mitransaction);
               return true;

           
            


        } catch (Exception ex) {
            if(mitransaction!=null)
            this.realizarRollback(mitransaction);

            System.err.println("Error en el Metodo ChequesPropios ------- " + ex.getMessage());
            return false;
        }
    }

    private String regresarDatosparaelArchivo(String idsBanco) {
         try {

              String total="#CHEQUE,VALOR,#CUENTA,#CHEQUERA\n";
              mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

              Query resultado2 = misessionFactory.getCurrentSession().createQuery("from transaccion where estado='pediente_compensar' "
                      + "and clasTransac='D_Externo_Cheque' and idBanco="+idsBanco);

              List col=resultado2.list();
               for (Iterator it = col.iterator(); it.hasNext();) {
                 Transaccion object = (Transaccion) it.next();
                 total+=","+object.getValor()+","+object.getCuentaExterna()+","+"\n";

             }

               //realizamos el commit
               this.realizarCommit(mitransaction);
               return total;





        } catch (Exception ex) {
            if(mitransaction!=null)
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo regresarDatosparaelArchivo ------- " + ex.getMessage());
            return "#CHEQUE,VALOR,#CUENTA,#CHEQUERA\n";
        }
    }

    private boolean llenar_TransaccionD(int idBanco,Cuenta cuenta, Double monto, String empleado,String ClasTrans,String Descripcion,String Estado) {
         try {
            mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco WHERE idBanco = " + idBanco);
            List milista = resultado.list();
            Banco cl = (Banco)milista.get(0);


            //Query resultado1 = misessionFactory.getCurrentSession().createQuery("from Cuenta WHERE idCuenta = " + cuentadepositar);
            //List milista1 = resultado1.list();
            Cuenta cl1 = cuenta; //(Cuenta)milista1.get(0);


            Query resultado2 = misessionFactory.getCurrentSession().createQuery("from UserLog WHERE idUserLog = '" + empleado+"'");
            List milista2 = resultado2.list();
            UserLog cl2 = (UserLog)milista2.get(0);


            Transaccion tr = new Transaccion();

            tr.setBanco(cl);
            tr.setCuenta(cl1);
            tr.setClasTransac(ClasTrans);
            tr.setCuentaClienteIdCliente(cl1.getCliente().getIdCliente());
            tr.setCuentaExterna(null);

            Descripcion des = new Descripcion();
            des.setDescripcion(Descripcion);

            tr.setDescripcion(des);
            tr.setEmpleado(cl2.getEmpleado());
            tr.setEstado(Estado);
            Calendar c = Calendar.getInstance();
            tr.setFecha(c.getTime());

            tr.setSaldoInicial(cl1.getSaldo());
            tr.setSaldoFinal(new BigDecimal(cl1.getSaldo().doubleValue()+monto));

            tr.setSucursal(cl2.getEmpleado().getSucursal());
            tr.setValor(new BigDecimal(monto));

            misessionFactory.getCurrentSession().save(des);
            misessionFactory.getCurrentSession().save(tr);

            this.realizarCommit(mitransaction);
            return true;

        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo llenar_TransaccionD ------- " + ex.getMessage());
            return false;
        }
    }

    private boolean llenar_TransaccionCP(int idBanco, Cuenta cuch, Cuenta cudep, Double monto, String empleado,String ClasTransac,String descripcion,String estado) {
       try{
        mitransaction = iniciarTransaccion(misessionFactory.getCurrentSession());

            Query resultado = misessionFactory.getCurrentSession().createQuery("from Banco WHERE idBanco = " + idBanco);
            List milista = resultado.list();
            Banco cl = (Banco)milista.get(0);


            //Query resultado1 = misessionFactory.getCurrentSession().createQuery("from Cuenta WHERE idCuenta = " + cuentadepositar);
            //List milista1 = resultado1.list();
            Cuenta principal = cuch; //(Cuenta)milista1.get(0);
            Cuenta deposito = cudep;

            Query resultado2 = misessionFactory.getCurrentSession().createQuery("from UserLog WHERE idUserLog = '" + empleado+"'");
            List milista2 = resultado2.list();
            UserLog cl2 = (UserLog)milista2.get(0);


            Transaccion tr = new Transaccion();

            tr.setBanco(cl);
            tr.setCuenta(principal);
            tr.setClasTransac(ClasTransac);
            tr.setCuentaClienteIdCliente(principal.getCliente().getIdCliente());
            tr.setCuentaExterna(deposito.getIdCuenta());

            Descripcion des = new Descripcion();
            des.setDescripcion(descripcion);

            tr.setDescripcion(des);
            tr.setEmpleado(cl2.getEmpleado());
            tr.setEstado(estado);
            Calendar c = Calendar.getInstance();
            tr.setFecha(c.getTime());

            tr.setSaldoInicial(principal.getSaldo());
            tr.setSaldoFinal(new BigDecimal(principal.getSaldo().doubleValue()+monto));

            tr.setSucursal(cl2.getEmpleado().getSucursal());
            tr.setValor(new BigDecimal(monto));

            misessionFactory.getCurrentSession().save(des);
            misessionFactory.getCurrentSession().save(tr);

            this.realizarCommit(mitransaction);
            return true;

        } catch (Exception ex) {
            this.realizarRollback(mitransaction);
            System.err.println("Error en el Metodo llenar_TransaccionCP ------- " + ex.getMessage());
            return false;
        }
    }





}
